home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Main.bin / ProcessManager.java < prev    next >
Encoding:
Java Source  |  1998-11-03  |  3.5 KB  |  162 lines
  1. package com.symantec.itools.lang;
  2.  
  3.  
  4. import java.io.InputStream;
  5. import java.io.IOException;
  6. import com.symantec.itools.io.InterleavedReader;
  7.  
  8.  
  9. /**
  10.  * @author Symantec Internet Tools Division
  11.  * @version 1.0
  12.  * @since VCafe 3.0
  13.  */
  14.  
  15. public class ProcessManager
  16. {
  17.     /**
  18.      * @since VCafe 3.0
  19.      */
  20.     protected Process process;
  21.  
  22.     public ProcessManager()
  23.     {
  24.     }
  25.  
  26.     /**
  27.      * @param p TODO
  28.      * @since VCafe 3.0
  29.      */
  30.  
  31.     public int monitorLaunchedProcess(Process p)
  32.     {
  33.         InterleavedReader interleavedReader;
  34.         InputStream       stdout;
  35.         InputStream       stderr;
  36.         int               exitStatus;
  37.  
  38.         process           = p;
  39.         interleavedReader = new InterleavedReader();
  40.         stdout            = process.getInputStream();
  41.         stderr            = process.getErrorStream();
  42.         interleavedReader.addInputStream(stdout);
  43.         interleavedReader.addInputStream(stderr);
  44.  
  45.         try
  46.         {
  47.             String s;
  48.  
  49.             while((s = interleavedReader.readLine()) != null)
  50.             {
  51.                 InputStream lastRead = interleavedReader.lastStreamRead();
  52.  
  53.                 if(lastRead == stdout)
  54.                 {
  55.                     processCommandOutput(s);
  56.                 }
  57.                 else if(lastRead == stderr)
  58.                 {
  59.                     processCommandError(s);
  60.                 }
  61.             }
  62.         }
  63.         catch(IOException ex)
  64.         {
  65.             ex.printStackTrace();
  66.             processCommandError("IOException: " + ex);
  67.         }
  68.  
  69.         interleavedReader.removeInputStream(stdout);
  70.         interleavedReader.removeInputStream(stderr);
  71.  
  72.         try
  73.         {
  74.             //replace process.waitFor(); with the fancy stuff below!
  75.             Waiter waiter;
  76.             Thread waiterThread;
  77.  
  78.             waiter       = new Waiter(p);
  79.             waiterThread = new Thread(waiter,"WaitOnSpawnedProcess");
  80.             waiterThread.start();
  81.             waiterThread.join();
  82.  
  83.             return (waiter.getResult());
  84.         }
  85.         catch(InterruptedException ex)
  86.         {
  87.             process.destroy();
  88.             ex.printStackTrace();
  89.         }
  90.  
  91.         exitStatus = process.exitValue();
  92.         process.destroy();
  93.         process    = null;
  94.  
  95.         return (exitStatus);
  96.     }
  97.  
  98.     /**
  99.      * @since VCafe 3.0
  100.      */
  101.  
  102.     public void destroyProcess()
  103.     {
  104.         process.destroy();
  105.     }
  106.  
  107.     /**
  108.      * @param str TODO
  109.      * @since VCafe 3.0
  110.      */
  111.  
  112.     protected void processCommandOutput(String str)
  113.     {
  114.         System.out.println(str);
  115.     }
  116.  
  117.     /**
  118.      * @param str TODO
  119.      * @since VCafe 3.0
  120.      */
  121.  
  122.     protected void processCommandError(String str)
  123.     {
  124.         System.out.println(str);
  125.     }
  126.  
  127.     final class Waiter
  128.         implements Runnable
  129.     {
  130.         // Process.waitFor() doesn't not respond to interrupt().
  131.         // This Waiter thread solves the problem
  132.         private Process process;
  133.         private int     result;
  134.  
  135.         Waiter(Process p)
  136.         {
  137.             this(p, -1);
  138.         }
  139.  
  140.         Waiter(Process p, int defaultValue)
  141.         {
  142.             process = p;
  143.             result  = defaultValue;
  144.         }
  145.  
  146.         public void run()
  147.         {
  148.             try
  149.             {
  150.                 result = process.waitFor();
  151.             }
  152.             catch(Throwable t)
  153.             {
  154.             }
  155.         }
  156.  
  157.         final int getResult()
  158.         {
  159.             return (result);
  160.         }
  161.     }
  162. }